// // import { fft } from 'fft-js'
// // const ifft = require('fft-js').ifft

// function befarr(arr) {
//     const len = arr.length
//     if ((len & (len - 1)) === 0) {
//         // 长度已经是 2 的 n 次幂，不需要补齐
//         return arr
//     } else {
//         // 计算补齐后的新长度
//         const paddedLength = Math.pow(2, Math.ceil(Math.log2(len)))
//         // 创建新数组并复制原数组内容
//         const newArr = arr.slice()
//         for (let i = len; i < paddedLength; i++) {
//             newArr.push(0) // 添加 0 直到长度达到 2 的 n 次幂
//         }
//         return newArr
//     }
// }

// // 输入：加速度波形 输出：速度波形
// export const get_vel = (y_quzhiliu, fs) => {
//     y_quzhiliu = befarr(y_quzhiliu)
//     const fmin = 10
//     const fmax = 1000
//     const type = 'bandpass'
//     const L = y_quzhiliu.length
//     const tp = L / fs
//     const detf = 1 / tp

//     const fft_x = fft(y_quzhiliu)

//     const p = Math.floor(fmin / detf)
//     const q = Math.ceil(fmax / detf)
//     const c = new Array(L).fill(0)
//     let c1 = []
//     let c2 = []
//     let c3 = []
//     if (type === 'bandpass' || type === 'bandstop') {
//         c1 = new Array(p).fill(0)
//         c2 = new Array(q - p).fill(1)
//         c3 = new Array(L - q).fill(0)
//     } else if (type === 'lowpass') {
//         const fmin = 0
//         const p = Math.floor(fmin / detf)
//         const q = Math.ceil(fmax / detf)
//         c1 = new Array(p).fill(0)
//         c2 = new Array(q - p).fill(1)
//         c3 = new Array(L - q).fill(0)
//     } else if (type === 'highpass') {
//         const fmax = fs / 2.56
//         const p = Math.floor(fmin / detf)
//         const q = Math.ceil(fmax / detf)
//         c1 = new Array(p).fill(0)
//         c2 = new Array(q - p).fill(1)
//         c3 = new Array(L - q).fill(0)
//     }
//     c.splice(0, p, ...c1)
//     c.splice(p, q - p, ...c2)
//     c.splice(q, L - q, ...c3)
//     const har_fre = c
//     const aw = []
//     for (let i = 0; i < fft_x.length; i++) {
//         const mulResult = []
//         for (let j = 0; j < fft_x[i].length; j++) {
//             mulResult.push(fft_x[i][j] * har_fre[i])
//         }
//         aw.push(mulResult)
//     }
//     var x_filter = ifft(aw)
//     var x_filter = x_filter.map(([first]) => first)
//     if (type === 'bandstop') {
//         for (let i = 0; i < L; i++) {
//             x_filter[i] = y_quzhiliu[i] - x_filter[i]
//         }
//     }

//     return x_filter.map((num) => Number(num.toFixed(6)))
// }
// export const getFFT = (data, sampleRate = 12800) => {
//     data = befarr(data)
//     const arr1 = []
//     let L = data.length // 数据长度
//     let N = Math.pow(2, Math.ceil(Math.log2(L))) // 确定 FFT 长度
//     N = parseInt(N) // 计算采样时刻
//     const sampleTime = sampleRate / data.length // 每个采样点之间的时间间隔（单位：毫秒）

//     const cosTable = new Array(N)
//     const sinTable = new Array(N)
//     const yf = new Array(N)

//     const invN = 1 / N
//     const angleIncrement = (Math.PI * 2) / N

//     for (let i = 0; i < N; i++) {
//         const angle = angleIncrement * i
//         cosTable[i] = Math.cos(angle)
//         sinTable[i] = Math.sin(angle)
//     }

//     for (let i = 0; i < N; i++) {
//         let realSum = 0
//         let imagSum = 0
//         for (let j = 0; j < L; j++) {
//             const angleIndex = (i * j) % N
//             realSum += data[j] * cosTable[angleIndex]
//             imagSum -= data[j] * sinTable[angleIndex]
//         }
//         yf[i] = { real: realSum, imag: imagSum }
//     }

//     const scale = 2 / L
//     for (let i = 0; i < Math.floor(N / 2); i++) {
//         const magnitude = Math.sqrt(yf[i].real * yf[i].real + yf[i].imag * yf[i].imag) * scale
//         arr1.push([i * sampleTime, magnitude.toFixed(6)])
//     }

//     return arr1
// }
// //输入：波形数据 输出：[频谱x轴,频谱y轴]
// export const getFFT1 = (data, sampleRate = 12800) => {
//     data = befarr(data)
//     const arr1 = []
//     let L = data.length // 数据长度
//     let N = Math.pow(2, Math.ceil(Math.log2(L))) // 确定 FFT 长度
//     N = parseInt(N) // 计算采样时刻
//     const sampleTime = sampleRate / data.length // 每个采样点之间的时间间隔（单位：毫秒）
//     const cosTable = new Array(N)
//     const sinTable = new Array(N)
//     for (let i = 0; i < N; i++) {
//         const angle = (2 * Math.PI * i) / N
//         cosTable[i] = Math.cos(angle)
//         sinTable[i] = Math.sin(angle)
//     }
//     const yf = new Array(N)
//     for (let i = 0; i < N; i++) {
//         let realSum = 0
//         let imagSum = 0
//         for (let j = 0; j < L; j++) {
//             const angleIndex = (i * j) % N
//             realSum += data[j] * cosTable[angleIndex]
//             imagSum -= data[j] * sinTable[angleIndex]
//         }
//         yf[i] = { real: realSum, imag: imagSum }
//     }
//     let point_l = 2
//     for (let i = 0; i < Math.floor(N / point_l); i++) {
//         const a = parseFloat(((2 * Math.sqrt(yf[i].real * yf[i].real + yf[i].imag * yf[i].imag)) / L).toFixed(6))
//         arr1.push([i * sampleTime, a])
//     }
//     return arr1
// }
// // 输入：加速度波形 输出：[ 包络谱x轴,包络谱y轴， 包络波形]
// export const get_ev = (xt, sample_rate) => {
//     xt = befarr(xt)
//     const fs = sample_rate
//     const L = xt.length
//     const k = Array.from({ length: L }, (_, i) => i)
//     const l = 1
//     const h = Math.floor(L / 2) + 1
//     const wfilt = Array.from({ length: L }, (_, i) => (i >= l - 1 && i < h ? 1 : 0))
//     const xt_fft = fft(xt)
//     let xf = []
//     for (let i = 0; i < L; i++) {
//         const mulResult = []
//         for (let j = 0; j < xt_fft[i].length; j++) {
//             mulResult.push(xt_fft[i][j] * wfilt[i])
//         }
//         xf.push(mulResult)
//     }
//     xf = ifft(xf)
//     const ENV = xf.map((c) => Math.sqrt(c[0] * c[0] + c[1] * c[1]))
//     let alpha = k.map((i) => (i * fs) / L)
//     alpha = alpha.slice(0, h - l)
//     const spectrum = fft(ENV)
//     const x = spectrum.map((c) => [(2 / L) * c[0], (2 / L) * c[1]])
//     let xSES = x.map((c) => Math.sqrt(c[0] * c[0] + c[1] * c[1]))
//     xSES = xSES.slice(0, h - l)
//     xSES[0] = 0
//     const realParts = xf.map(([real]) => real)
//     const result1 = alpha.map((val) => Math.round(val * 1e6) / 1e6)
//     const result2 = xSES.map((val) => Math.round(val * 1e6) / 1e6)
//     const result3 = realParts.map((val) => Math.round(val * 1e6) / 1e6)
//     return [result1, result2, result3]
// }
// // 输入：加速度波形 ，输出 包络波形
// export const get_env = (xt, sample_rate) => {
//     xt = befarr(xt)
//     const L = xt.length
//     const k = Array.from({ length: L }, (_, i) => i)
//     const l = 1
//     const h = Math.floor(L / 2) + 1
//     const wfilt = Array.from({ length: L }, (_, i) => (i >= l - 1 && i < h ? 1 : 0))
//     const xt_fft = fft(xt)
//     let xf = []
//     for (let i = 0; i < L; i++) {
//         const mulResult = []
//         for (let j = 0; j < xt_fft[i].length; j++) {
//             mulResult.push(xt_fft[i][j] * wfilt[i])
//         }
//         xf.push(mulResult)
//     }
//     xf = ifft(xf)
//     const ENV = xf.map((c) => Math.sqrt(c[0] * c[0] + c[1] * c[1]))
//     return ENV
// }
// // 输入包络波形，输出包络谱
// export const get_env_spec = (env) => {
//     const L = env.length
//     const fs = 1 // 可根据需要自定义采样率
//     const k = Array.from({ length: L }, (_, i) => i)
//     const l = 1
//     const h = Math.floor(L / 2) + 1
//     const alpha = k.map((i) => (i * fs) / L).slice(0, h - l)
//     const spectrum = fft(env)
//     const x = spectrum.map((c) => [(2 / L) * c[0], (2 / L) * c[1]])
//     let xSES = x.map((c) => Math.sqrt(c[0] * c[0] + c[1] * c[1])).slice(0, h - l)
//     xSES[0] = 0
//     return [alpha, xSES]
// }
// // 输入：时域波形数据，采样频率, 输出：倒谱
// export const get_cep_strum = (signal, fs = 12800) => {
//     signal = befarr(signal)
//     let spectrum = fft(signal)

//     //   # 第二步：取对数幅度
//     let logAbsSpectrum = []
//     // 定义一个极小值
//     let eps = 2.220446049250313e-16 // JavaScript中使用科学计数法表示
//     for (let i = 0; i < spectrum.length; i++) {
//         let realPart = spectrum[i][0]
//         let imagPart = spectrum[i][1]
//         let absValue = Math.sqrt(realPart * realPart + imagPart * imagPart) // 计算模长
//         let logValue = Math.log(absValue + eps) // 计算对数并加上eps
//         logAbsSpectrum.push(logValue)
//     }

//     // 打印对数绝对值数组
//     //   # 第三步：计算对数幅度的IFFT（快速傅里叶逆变换）
//     // 将对数幅度转换为复数形式（实部为对数幅度，虚部为0）
//     let complex_spectrum = logAbsSpectrum.map((value) => [value, 0])
//     // 执行 IFFT 操作

//     let cepstrum_complex = ifft(complex_spectrum)

//     // 提取实部作为逆变换后的结果
//     let cepstrum = cepstrum_complex.map((value, index) => {
//         return [(1 / fs) * (index + 1) * 1000, value[0]]
//     })

//     return cepstrum
// }

// function hannWindow(n) {
//     const window = new Array(n)
//     for (let i = 0; i < n; i++) {
//         window[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (n - 1)))
//     }
//     return window
// }
// function complexMultiply(aReal, aImag, bReal, bImag) {
//     const real = aReal * bReal - aImag * bImag
//     const imag = aReal * bImag + aImag * bReal
//     return [real, imag]
// }
// // 输入 波形1 ，波形2 ，频率,输出交叉相位
// export const get_cross_phase = (signal1, signal2, fs, nperseg = 1024) => {
//     signal1 = befarr(signal1)
//     signal2 = befarr(signal2)
//     // 计算信号长度
//     const N = Math.min(signal1.length, signal2.length)
//     // 分段窗口
//     const window = hannWindow(nperseg)
//     // 初始化结果数组

//     let cps = []
//     // 遍历每个段
//     for (let i = 0; i < N; i += nperseg) {
//         // 截取段
//         const segment1 = signal1.slice(i, i + nperseg)
//         const segment2 = signal2.slice(i, i + nperseg)
//         // 加窗
//         const windowed1 = segment1.map((x, idx) => x * window[idx])
//         const windowed2 = segment2.map((x, idx) => x * window[idx])
//         // FFT变换
//         const fft1 = fft(windowed1)
//         const fft2 = fft(windowed2)
//         // 计算交叉功率谱密度
//         let cpsd_segment = fft1.map((val, idx) => complexMultiply(val[0], val[1], fft2[idx][0], fft2[idx][1]))
//         // freqs.push()
//         // 添加到结果数组
//         cps = cpsd_segment
//     }
//     let amplitude_spectrum = []
//     let phase_spectrum = []
//     for (let i = 0; i < N; i++) {
//         let cp = cps[i]
//         if (cp) {
//             amplitude_spectrum.push([(i * fs) / N, Math.sqrt(cp[0] * cp[0] + cp[1] * cp[1])])
//             phase_spectrum.push([(i * fs) / N, Math.atan2(cp[1], cp[0])])
//         }
//     }
//     return [amplitude_spectrum, phase_spectrum]
// }
// //输入  波形1 ,输出包络解调
// export const get_env_elope = (x, Fs, low = 0, high = 0, p = 0.999) => {
//     x = befarr(x)
//     let L = x.length
//     let k = Array.from({ length: L }, (_, i) => i)
//     // 设置滤波器边界
//     let bpf = [low, high]
//     bpf.sort((a, b) => a - b)
//     let l, h
//     if (bpf[0] === 0 && bpf[1] === 0) {
//         // 不进行滤波
//         let hf = fft(x)
//         var xf = ifft(hf)
//         l = 1
//         h = Math.floor(L / 2) + 1
//     } else {
//         l = Math.max(Math.floor((bpf[0] * L) / Fs), 1)
//         h = Math.floor((bpf[1] * L) / Fs)
//         // 在JavaScript中模拟滤波过程比较复杂，通常我们会对频域数据进行操作，这里简化处理
//         // 实际情况请根据具体需求实现滤波器
//         let hf = fft(x)
//         let filt = new Array(L)
//         filt.fill(0)
//         for (let i = l - 1; i < h; i++) {
//             filt[i] = 1
//         }
//         let filteredHf = hf.map((val, i) =>
//             //  val * filt[i]
//             {
//                 return [val[0] * filt[i], val[1] * filt[i]]
//             },
//         )
//         var xf = ifft(filteredHf)
//     }

//     let ENV = xf.map((c) => Math.sqrt(c[0] * c[0] + c[1] * c[1])) // 计算包络
//     let ENVfft = fft(ENV) // 对包络进行FFT
//     let a = ENVfft.map((c) => [(2 / L) * c[0], (2 / L) * c[1]]) // 计算包络谱并归一化
//     // 截取有效频谱部分
//     let alpha = k.slice(l - 1, h).map((freqIndex) => (freqIndex * Fs) / L)
//     let xSES = a.map((c) => Math.sqrt(c[0] * c[0] + c[1] * c[1]))
//     xSES[0] = 0
//     let arr = []
//     alpha.forEach((e, i) => {
//         arr.push([e, xSES[i]])
//     })
//     return arr
// }
